package com.loong.android.tools;

import android.text.TextUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;

/**
 * 日期和时间的工具类
 */
public class DateTime {

    /**
     * 文本转时间
     * @param content 文本内容
     * @param format 格式，默认为HH:mm:ss
     */
    public static Date toTime(String content, String format) {
        if(TextUtils.isEmpty(format))  format = "HH:mm:ss";
        Date date = new Date();
        if (content == null || content.equals("")) return date;
        SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
        try {
            date = sdf.parse(content);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 文本转时间，格式：HH:mm:ss
     * @param content 文本内容
     */
    public static Date toTime(String content) {
        return toTime(content, "HH:mm:ss");
    }

    /**
     * 时间转文本
     * @param time 时间
     * @param format 格式，默认为HH:mm:ss
     */
    public static String time2Str(Date time, String format) {
        if(TextUtils.isEmpty(format))  format = "HH:mm:ss";
        if (time == null) return "";
        SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
        return sdf.format(time);
    }

    /**
     * 时间转文本，格式：HH:mm:ss
     * @param time 时间
     */
    public static String time2Str(Date time) {
        return time2Str(time,"HH:mm:ss");
    }

    /**
     * 当前时间转文本，格式：HH:mm:ss
     */
    public static String time2Str() {
        return time2Str(new Date());
    }

    /**
     * 文本转为日期
     * @param content 文本内容
     * @param format 日期格式，默认为yyyy-MM-dd
     */
    public static Date toDate(String content, String format) {
        if(TextUtils.isEmpty(format)) format = "yyyy-MM-dd";
        Date date = new Date();
        if (content == null || content.equals("")) return date;
        SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
        try {
            date = sdf.parse(content);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 文本转为日期
     * @param content 文本内容
     */
    public static Date toDate(String content) {
        return toDate(content, "yyyy-MM-dd");
    }

    /**
     * 日期转文本
     * @param date 日期
     * @param format 日期格式，默认为yyyy-MM-d
     */
    public static String time2Date(Date date, String format) {
        if(TextUtils.isEmpty(format)) format = "yyyy-MM-dd";
        if (date == null) return "";
        SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
        return sdf.format(date);
    }

    /**
     * 日期转文本，格式为yyyy-MM-d
     * @param date 日期
     */
    public static String time2Date(Date date) {
        return time2Date(date, "yyyy-MM-dd");
    }

    /**
     * 当前日期转文本
     */
    public static String time2Date() {
        return time2Date(new Date());
    }

    /**
     * 文本转日期时间
     * @param content 文本内容
     * @param format date格式，默认为yyyy-MM-dd HH:mm:ss
     */
    public static Date toDateTime(String content, String format) {
        if(TextUtils.isEmpty(format)) format = "yyyy-MM-dd HH:mm:ss";
        Date date = new Date();
        if (content == null || content.equals("")) return date;
        SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
        try {
            date = sdf.parse(content);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 文本转日期时间，格式为yyyy-MM-dd HH:mm:ss
     * @param content 文本内容
     */
    public static Date toDateTime(String content) {
        return toDateTime(content, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 日期时间转文本
     * @param date 日期时间
     * @param format 日期时间格式，默认为yyyy-MM-dd HH:mm:ss
     */
    public static String dateTime2Str(Date date, String format) {
        if(TextUtils.isEmpty(format)) format = "yyyy-MM-dd HH:mm:ss";
        if (date == null) return "";
        SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
        return sdf.format(date);
    }

    /**
     * 日期时间转文本
     * @param date 日期时间
     */
    public static String dateTime2Str(Date date) {
        return dateTime2Str(date, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 日期时间转文本
     */
    public static String dateTime2Str() {
        return dateTime2Str(new Date());
    }

    /**
     * 取现行时间
     */
    public static Date currentTime() {
        return new Date();
    }

    /**
     * 取指定日期时间中的年份
     *
     * @param date 日期时间
     */
    public static int getYear(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.YEAR);
    }

    /**
     * 取当前时期时间中的年份
     */
    public static int getYear() {
        return getYear(new Date());
    }

    /**
     * 取指定日期时间中的月份
     * @param date 日期时间
     */
    public static int getMonth(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.MONTH) + 1;//注意：Calendar月份从0开始
    }

    /**
     * 取当前日期时间中的月份
     */
    public static int getMonth() {
        return getMonth(new Date());
    }

    /**
     * 取日期时间中月份的第几天
     * @param date 日期时间
     */
    public static int getDay(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.DAY_OF_MONTH);
    }

    /**
     * 取当前日期时间中月份的第几天
     */
    public static int getDay() {
        return getDay(new Date());
    }

    /**
     * 取日期时间24小时制的小时数
     * @param date 日期时间
     */
    public static int getHour24(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.HOUR_OF_DAY);
    }

    /**
     * 取当前日期时间24小时制的小时数
     */
    public static int getHour24() {
        return getHour24(new Date());
    }

    /**
     * 取日期时间12小时制的小时数
     * @param date 日期时间
     */
    public static int getHour(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.HOUR);
    }

    /**
     * 取当前日期时间24小时制的小时数
     */
    public static int getHour() {
        return getHour(new Date());
    }

    /**
     * 取分钟数
     * @param date 日期时间
     */
    public static int getMinute(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.MINUTE);
    }

    /**
     * 取当前日期时间的分钟数
     */
    public static int getMinute() {
        return getMinute(new Date());
    }

    /**
     * 取日期时间中的秒数
     * @param date 日期时间
     */
    public static int getSecond(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.SECOND);
    }

    /**
     * 取当前日期时间中的秒数
     */
    public static int getSecond() {
        return getSecond(new Date());
    }

    /**
     * 判断指定日期时间是上午还是下午。false=上午(am); true=下午(pm)
     * @param date 日期时间
     */
    public static boolean amOrPm(Date date) {
        if (date == null) return false;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.AM_PM) == Calendar.PM;
    }

    /**
     * 判断当前日期时间是上午还是下午。false=上午(am); true=下午(pm)
     */
    public static boolean amOrPm() {
        return amOrPm(new Date());
    }

    /**
     * 取指定日期时间为一周中的星期几。1~7分别为星期一到星期天
     * @param date 日期时间
     */
    public static int getDayOfWeek(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        int dn = cal.get(Calendar.DAY_OF_WEEK);
        if (dn == Calendar.SUNDAY) return 7;
        else return dn - 1;
    }

    /**
     * 取当前日期时间为一周中的星期几。1~7分别为星期一到星期天
     */
    public static int getDayOfWeek() {
        return getDayOfWeek(new Date());
    }

    /**
     * 取指定日期时间为月份中的第几周
     * @param date 日期时间
     */
    public static int getWeekOfMonth(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setFirstDayOfWeek(Calendar.MONDAY); // 设置每周的第一天为星期一
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);// 每周从周一开始
        cal.setMinimalDaysInFirstWeek(7); // 设置每周最少为7天
        cal.setTime(date);
        return cal.get(Calendar.WEEK_OF_MONTH);
    }

    /**
     * 取当前日期时间为月份中的第几周
     */
    public static int getWeekOfMonth() {
        return getWeekOfMonth(new Date());
    }

    /**
     * 取指定日期时间为一年中的第几天
     * @param date 日期时间
     */
    public static int getDayOfYear(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.DAY_OF_YEAR);
    }

    /**
     * 取当前日期时间为一年中的第几天
     */
    public static int getDayOfYear() {
        return getDayOfYear(new Date());
    }

    /**
     * 取指定日期时间为一年中的第几周
     * @param date 日期时间
     */
    public static int getWeekOfYear(Date date) {
        if (date == null) return 0;
        Calendar cal = Calendar.getInstance();
        cal.setFirstDayOfWeek(Calendar.MONDAY); // 设置每周的第一天为星期一
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);// 每周从周一开始
        cal.setMinimalDaysInFirstWeek(7); // 设置每周最少为7天
        cal.setTime(date);
        return cal.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 取当前日期时间为一年中的第几周
     */
    public static int getWeekOfYear() {
        return getWeekOfYear(new Date());
    }

    /**
     * 取现行时间的时间戳
     * @param milliseconds milliseconds 是否精确到毫秒
     */
    public static long getCurrentTimestamps(boolean milliseconds) {
        long timestamps = System.currentTimeMillis();
        if (!milliseconds) timestamps = timestamps / 1000;
        return timestamps;
    }

    /**
     * 取现行时间的毫秒级的时间戳
     */
    public static long getCurrentTimestamps() {
        return System.currentTimeMillis();
    }

    /**
     * 取现行时间的时间戳文本
     * @param milliseconds 是否精确到毫秒
     */
    public static String getCurrentTimestampsStr(boolean milliseconds) {
        long timestamps = System.currentTimeMillis();
        if (!milliseconds) timestamps = timestamps / 1000;
        return String.valueOf(timestamps);
    }

    /**
     * 取现行时间的毫秒级时间戳文本
     */
    public static String getCurrentTimestampsStr() {
        return String.valueOf(System.currentTimeMillis());
    }

    /**
     * 指定日期时间转为时间戳
     * @param date 日期时间
     * @param milliseconds 是否精确到毫秒
     */
    public static long getTimestamps(Date date, boolean milliseconds) {
        if (date == null) return 0;
        long time = date.getTime();
        if (!milliseconds) time = time / 1000;
        return time;
    }

    public static long getTimestamps(Date date) {
        if (date == null) return 0;
        return date.getTime();
    }

    /**
     * 指定日期时间转时间戳文本
     * @param date 日期时间
     * @param milliseconds 是否精确到毫秒
     */
    public static String getTimestampsStr(Date date, boolean milliseconds) {
        if (date == null) return "";
        long time = date.getTime();
        if (!milliseconds) time = time / 1000;
        return String.valueOf(time);
    }

    /**
     * 指定日期时间转毫秒级时间戳文本
     * @param date 日期时间
     */
    public static String getTimestampsStr(Date date) {
        if (date == null) return "";
        return String.valueOf(date.getTime());
    }

    //13位或10位的长整数型时间戳
    public static Date timestampsStr2Date(long timestamp) {
        if (timestamp <= 1000000000) timestamp = timestamp * 1000;
        return new Date(timestamp);
    }

    /**
     * 时间戳文本转为日期时间数据
     * @param timestampsStr 时间戳文本，支持10位(秒级)或13位(毫秒级)
     */
    public static Date timestampsStr2Date(String timestampsStr) {
        if (timestampsStr.length() == 10) timestampsStr += "000";
        return new Date(Text.toLong(timestampsStr));
    }

    /**
     * 取两个日期时间的间隔
     * @param date1 日期时间1
     * @param date2 日期时间2
     */
    public static long intervals(Date date1, Date date2) {
        if (date1 == null || date2 == null) return 0;
        return date2.getTime() - date1.getTime();
    }

    /**
     * 取当前时间与指定时间的间隔
     * @param date 日期时间
     */
    public static long intervals(Date date) {
        return intervals(new Date(), date);
    }

    /**
     * 计算时间的增加或减少
     * @param date 日期时间
     * @param type 类型。1=年; 2=月; 3=日; 4=周; 5=时; 6=分; 7=秒
     * @param value 增加或减少的值
     */
    public static Date calculate(Date date, int type, int value) {
        if (date == null) date = new Date();
        Calendar cal = Calendar.getInstance();
        cal.setFirstDayOfWeek(Calendar.MONDAY); // 设置每周的第一天为星期一
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);// 每周从周一开始
        cal.setMinimalDaysInFirstWeek(7); // 设置每周最少为7天
        cal.setTime(date);
        switch (type) {
            case 1://增减年
                cal.add(Calendar.YEAR, value);
                break;
            case 2://增减月
                cal.add(Calendar.MONTH, value);
                break;
            case 3://增减周
                cal.add(Calendar.WEEK_OF_YEAR, value);
                break;
            case 4://增减日
                cal.add(Calendar.DAY_OF_YEAR, value);
                break;
            case 5://增减时
                cal.add(Calendar.HOUR_OF_DAY, value);
                break;
            case 6://增减分
                cal.add(Calendar.MINUTE, value);
                break;
            case 7://增减秒
                cal.add(Calendar.SECOND, value);
                break;
        }
        return cal.getTime();
    }
}
